// #include <iostream>
// #include <cstring>
// #include <cctype>

// using namespace std;

// class String {
// public:
//     String() : n(0), capacity(16), str(new char[16]) {
//         str[0] = '\0';
//     }
//     String(const char* s) : n(strlen(s)), capacity(n * 2), str(new char[capacity]) {
//         strcpy(str, s);
//     }
//     String(const String& other) : n(other.n), capacity(other.capacity), str(new char[capacity]) {
//         strcpy(str, other.str);
//     }
//     ~String() {
//         delete[] str;
//     }

//     const char* c_str() const {
//         return str;
//     }

//     void clear() {
//         if (str != NULL) {
//             delete[] str;
//         }
//         n = 0;
//         capacity = 16;
//         str = new char[capacity];
//         str[0] = '\0';
//     }

//     String& operator+=(char c) {
//         if (n + 1 >= capacity) {
//             int size = capacity * 2;
//             if (size < 0) { // Too many elements
//                 size = 1 << 30;  // Good luck allocating 2 ^ 30 elements
//             }
//             capacity = size;
//             char* newStr = new char[capacity];
//             strcpy(newStr, str);
//             delete[] str;
//             str = newStr;
//         }
//         str[n++] = c;  // Append c to the end of str
//         str[n] = '\0'; // Null terminate the string
//         return *this;
//     }

//     int getSize() const { return n; }
//     int getcapacity() const { return capacity; }

//     //// Your Implementation.
//     const char& operator[](int index) const;
//     friend ostream& operator<<(ostream& os, const String& s);
//     friend istream& operator>>(istream& is, String& s);

// private:
//     int n; // Length of the string
//     int capacity; // Capacity of the buffer
//     char* str; // Buffer to store the string
// };

// class StringJoiner {
// public:
//     StringJoiner(char c = ' ') : c(c) {}

//     String operator()(const String& a, const String& b) const;

// private:
//     char c;
// };
#include "mystring.h"

#include <cstring>
#include <iostream>

using namespace std;

const char& String::operator[](int index) const {
    return str[index];
}

ostream& operator<<(ostream& os, const String& s) {
    os << "s.size = " << s.getSize() << endl;
    os << "s.capacity = " << s.getcapacity() << endl;
    os << "s.str = ";
    for (int i = 0; i < s.getSize(); ++i) {
        os << s[i];
    }
    // os << "s.str = " << s. << endl;
    os << endl;
    // os << s.c_str()<<endl;
    return os;
}
istream& operator>>(istream& is, String& s) {
    char buffer[1024];  // Temporary buffer for input
    is >> buffer;       // Read into the buffer
    s.clear();
    for (int i = 0; i < strlen(buffer); ++i) {
        s += buffer[i];  // Append each character to the String object
    }
    // s += '\0';  // Null terminate the string

    return is;
}

String StringJoiner::operator()(const String& a, const String& b) const {
    String result;
    result.clear();  // Clear the result string
    for (int i = 0; i < a.getSize(); ++i) {
        result += a[i];  // Append characters from the first string
    }
    result += c;  // Append the separator character
    for (int i = 0; i < b.getSize(); ++i) {
        result += b[i];  // Append characters from the second string
    }
    return String(result.c_str());
}